hunt.templates.util source code

1 module hunt.templates.util;
2 
3 import hunt.templates.element;
4 import hunt.templates.rule;
5 import std.stdio;
6 import std.regex;
7 
8 class Util
9 {
10     static int level = 1;
11 public:
12     static void debug_ast(Element e)
13     {
14         level++;
15         switch (e.type)
16         {
17         case Type.Comment:
18             {
19                 auto elm = cast(ElementComment)(e);
20                 printSpace(level);
21                 writeln("Type : Comment,  text : ", elm.text);
22                 break;
23             }
24         case Type.Condition:
25             {
26                 auto elm = cast(ElementConditionContainer)(e);
27                 printSpace(level);
28                 writeln("Type : Condition ");
29                 printSpace(level);
30                 writeln("       +++++++children begin ");
31                 foreach (child; elm.children)
32                 {
33                     debug_ast(child);
34                 }
35                 printSpace(level);
36                 writeln("       +++++++children end ");
37                 break;
38             }
39         case Type.ConditionBranch:
40             {
41                 auto elm = cast(ElementConditionBranch)(e);
42                 printSpace(level);
43                 writeln("Type : ConditionBranch,  condition_type : ", elm.condition_type);
44                 printSpace(level);
45                 writeln("       ElementExpression begin ");
46                 debug_ast(elm.condition);
47                 printSpace(level);
48                 writeln("       ElementExpression end ");
49                 printSpace(level);
50                 writeln("       +++++++children begin ");
51                 foreach (child; elm.children)
52                 {
53                     debug_ast(child);
54                 }
55                 printSpace(level);
56                 writeln("       +++++++children end ");
57                 break;
58             }
59         case Type.Expression:
60             {
61                 auto elm = cast(ElementExpression)(e);
62                 printSpace(level);
63                 writeln("Type : Expression,  Function : ", elm.func,
64                         ", command :", elm.command, ", result :", elm.result.toString);
65                 printSpace(level);
66                 writeln("       =====args begin=====");
67                 foreach (child; elm.args)
68                 {
69                     debug_ast(child);
70                 }
71                 printSpace(level);
72                 writeln("       =====args end=======");
73                 printSpace(level);
74                 writeln("       +++++++children begin ");
75                 foreach (child; elm.children)
76                 {
77                     debug_ast(child);
78                 }
79                 printSpace(level);
80                 writeln("       +++++++children end ");
81                 break;
82             }
83         case Type.Loop:
84             {
85                 auto elm = cast(ElementLoop)(e);
86                 printSpace(level);
87                 writeln("Type : Loop,  Loop : ", elm.loop, " key:", elm.key,
88                         " value: ", elm.value);
89                 printSpace(level);
90                 writeln("       ElementExpression begin ");
91                 debug_ast(elm.list);
92                 printSpace(level);
93                 writeln("       ElementExpression end ");
94                 printSpace(level);
95                 writeln("       +++++++children begin ");
96                 foreach (child; elm.children)
97                 {
98                     debug_ast(child);
99                 }
100                 printSpace(level);
101                 writeln("       +++++++children end ");
102                 break;
103             }
104         case Type.Main:
105             {
106                 printSpace(level);
107                 writeln("----------AST TREE DEBUG-----------");
108                 foreach (child; e.children)
109                 {
110                     debug_ast(child);
111                 }
112                 break;
113             }
114         case Type.String:
115             {
116                 auto elm = cast(ElementString)(e);
117                 printSpace(level);
118                 writeln("Type : String,  text : ", elm.text);
119                 break;
120             }
121         default:
122             {
123                 break;
124             }
125         }
126 
127         level--;
128     }
129 
130     static printSpace(int num)
131     {
132         for (size_t i = 0; i < num; i++)
133             write("       ");
134     }
135 
136     static bool is_num(string str)
137     {
138         auto m = match(str, regex(`^[0-9]\d*$`));
139         return !m.empty;
140     }
141 }